Controlling ssd performance by queue depth

ABSTRACT

Improving performance in solid state devices (SSDs) by controlling or throttling the depth of the request queue. In one implementation, a method includes monitoring a request queue in a solid state device (an SSD), the request queue comprising a first request and a second request having an actual time interval therebetween, determining a queue depth for the request queue, determining a target interval based on the queue depth and a target queue depth, and responsive to the actual time interval being less than the target interval, delaying acting on the second request until after the target interval.

BACKGROUND

Solid state devices or drives (also known as SSDs) are data storage devices that use integrated circuit assemblies, and typically utilize Flash memory protocols.

Whenever there is a read request or a write request to the SSD, the SSD tries to complete the request as soon as possible. At times, the drive is very busy or may be not busy at all, depending on the incoming requests. Because of this, there are performance instabilities, such as IOPS (input/output operations per second) variations and response time variations.

SUMMARY

This disclosure is directed to improving performance instability in solid state devices (SSDs), particularly, decreasing the instability, by controlling or throttling the SSD performance. By improving the performance, the product competitiveness improves.

This disclosure provides, in one particular implementation, a method. The method includes monitoring a request queue in a solid state device (an SSD), the request queue comprising a first request and a second request having an actual time interval therebetween, determining a queue depth for the request queue, determining a target interval based on the queue depth and a target queue depth, and responsive to the actual time interval being less than the target interval, delaying acting on the second request until after the target interval.

In another particular implementation, another method is provided. The method includes monitoring a request queue to a semiconductor storage device (an SSD), the request queue having a depth and comprising at least a first request, a second request, and an outgoing interval between the requests, and responsive to the outgoing interval being less than a target interval based on a target queue depth and the queue depth, setting an actual outgoing interval to be no less than the target interval and acting on the second request after expiration of the target interval.

In another particular implementation, a system is provided. The system includes a solid state device (SSD) and a host, and an interval throttling module stored in memory and implemented by a processor. The interval throttling module is located in a data request completion path of the system and comprises a queue memory unit, a delay unit configured to delay acting on a second request if an outgoing interval between a first request and the second request is less than a target interval, and a calculator unit configured to dynamically adjust the target interval based on a throttle queue depth.

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. These and various other features and advantages will be apparent from a reading of the following detailed description.

BRIEF DESCRIPTION OF THE DRAWING

The described technology is best understood from the following Detailed Description describing various implementations read in connection with the accompanying drawing.

FIG. 1 is a schematic diagram of an example SSD device incorporating an interval throttling module of this disclosure.

FIG. 2 is a schematic diagram of another example SSD device incorporating an interval throttling module of this disclosure.

FIG. 3 is a schematic diagram showing an example timing of requests and throttled action on those requests.

FIG. 4 is an example stepwise method for throttling according to this disclosure.

FIG. 5 is an example stepwise method for calculating the delay interval for throttling, based on queue depth, according to this disclosure.

DETAILED DESCRIPTION

When there is a read request or a write request to the SSD, the SSD tries to complete the request as soon as possible. At times, the drive is very busy or not busy at all, depending on the incoming requests. The present disclosure provides a methodology to improve the SSD performance by controlling (e.g., throttling) the spacing between requests (the target interval, or T_TargetInterval) in the queue to be acted on based on the throttle queue depth.

In general, a throttling module of this disclosure monitors and controls the number or requests residing in the queue to be acted on. The throttling module utilizes a control algorithm to calculate an average throttle queue depth, then modulates the target interval (T_TargetInterval) between requests, so that the average throttle queue depth moves closer to the target queue depth.

In general, the throttling module of this disclosure has three sub-units, a queue unit, a delay unit and a target interval calculator. The queue unit stores the queue of read or write requests, or both read and write requests, and may be, e.g., a volatile memory. The delay unit receives the request and sends it to be acted on no sooner than after the target interval (T_TargetInterval), which adjusts based on the queue depth. The calculator calculates the target interval, which is the target time between each request's completion, taking into account the average queue depth in the queue unit.

By setting a minimum time between acting on requests, i.e., the T_TargetInterval, the IOPS can be precisely controlled, resulting in decreased performance variations and significantly improved overall SSD performance. By basing the target interval on an internal parameter such as the depth of the queue, a more universal and complete control is obtained.

It is noted that throttling does not improve overall performance in the sense of increased speed, but rather, throttling makes the performance more consistent, which is especially desirable in large network (e.g., “Cloud”) environments where a service level agreement often requires specific response times. It is performance in this broader sense that is improved, rather than the narrow usage of performance referring to simple throughput.

In the following description, reference is made to the accompanying drawing that forms a part hereof and in which is shown by way of illustration at least one specific implementation. The following description provides additional specific implementations. It is to be understood that other implementations are contemplated and may be made without departing from the scope or spirit of the present disclosure. The following detailed description, therefore, is not to be taken in a limiting sense. While the present disclosure is not so limited, an appreciation of various aspects of the disclosure will be gained through a discussion of the examples, including the figures, provided below. In some instances, a reference numeral may have an associated sub-label consisting of a lower-case letter to denote one of multiple similar components. When reference is made to a reference numeral without specification of a sub-label, the reference is intended to refer to all such multiple similar components.

FIG. 1 illustrates a system 100 including a solid state drive (SSD) 102 and a host 104, the system 100 including a throttling module 106 incorporated therein, in this particular implementation, in the SSD 102. The SSD 102 has at least one Flash memory 108, here shown as a first memory 108 a and another memory 108 x. In other implementations, the memory 108 may be PCRAM (phase-change RAM), MRAM (magnetoresistive RAM), STTRAM (spin-transfer torque RAM), FeRAM (ferroelectric RAM), or ReRAM (resistive RAM). The SSD 102 also includes a back-end controller 110 and a front-end controller 112. In some implementations, one hardware element, or controller, provides the functions of both the back-end controller 110 and the front-end controller 112.

Within the SSD 102 and between the host 104 and the SSD 102 are various data paths, particularly, read/write submission paths shown as dotted arrows and various completion paths shown as solid arrows. Within the SSD 102, the submission and completion paths run between the memories 108, the back-end controller 110 and the front-end controller 112. The submission and completion paths also run within each element (e.g., the host 104, the back-end controller 110 and the front-end controller 112). In the particular system 100 of FIG. 1, the throttling module 106 is positioned between the back-end controller 110 and the front-end controller 112, in the completion path of the read and write requests.

In an alternate system 200 shown in FIG. 2, the throttling module is positioned outside of the SSD, between the SSD and the host in a completion path. Particularly, the system 200 has an SSD 202 and a host 204, with a throttling module 206 positioned between the SSD 202 and the host 204. As in the system 100, the SSD 202 has at least one Flash memory 208 (shown as memory 208 a and memory 208 x), a back-end controller 210 and a front-end controller 212, with appropriate submission paths and completion paths between the various components.

The throttling module can be positioned in any location within the system 100 or system 200, within a data path. Although a completion path is desired, the throttling module could be present in a submission path. As another example, the throttling module can be positioned between Flash memory and the back-end controller.

Returning to FIG. 1, the throttling module 106 includes several sub-modules, including a throttle queue unit 161, a delay unit 162, and a target interval (T_TargetInterval) calculator 163. The queue unit 161 may be, e.g., a volatile memory, non-volatile memory, or persistent memory for storing the request queue. Both the delay unit 162 and the calculator 163 may be implemented as and/or processed as software or other machine-readable instructions. In alternate implementations, the throttling modules may be implemented in hardware. When implemented as processes in software, the modules may be provided as executable code which, when run on a device having a processor and computer capability, implement a process or method as described. The modules or code may be stored on a computer device or may be stored on a memory and may be connected to or downloaded to a computer device.

Although not illustrated, the throttling module 106 also may include any or all of a read/write splitter, a throttling unit which can have a first portion for the read actions and a second portion for the write actions, and a read/write merger.

The throttling module 106, 206 is configured to control the interval between all read and write requests. In alternate implementations, the read requests and write requests are throttled independently.

FIG. 3 shows an example of spacing out (e.g., throttling) the requests in the queue by delaying acting on the requests, if needed, to obtain a minimum interval (T_TargetInterval) between outgoing requests. These requests may be only read requests, only write requests, or both read and write requests.

A plurality of requests 302, either read requests or write requests, or both, are shown in FIG. 3 as a queue of requests 302 a, 302 b, 302 c, 302 d, 302 e, 302 f that arrive in variable intervals, to be acted on, the intervals shown as T_OutgoingInterval. T_OutgoingInterval, as used herein, is either (1) the elapsed time between the time the last outgoing request was completed and the current time t if the current request is not completed yet, or (2) the actual time interval between two consecutive outgoing requests once both of them are actually completed. The delay unit of the throttling module (e.g., the delay unit 162 of the throttling module 106) rectifies the timing of the queue of the requests 302 (e.g., the queue unit 161) to the desired interval, T_TargetInterval, as outgoing requests 304. The T_TargetInterval is dynamic, dependent on the queue length.

Because incoming request 302 a is the first sent, the corresponding outgoing request 304 a is acted on without delay, essentially immediately. The second incoming request 302 b occurs at an actual T_IncomingInterval where the corresponding T_OutgoingInterval will be less than the desired interval T_TargetInterval if this request is acted on immediately upon receipt; thus, the corresponding outgoing request 304 b is delayed so that the interval between request 304 a and 304 b (i.e., T_OutgoingInterval) is T_TargetInterval. Similarly, the third incoming request 302 c occurs at an actual T_IncomingInterval where the corresponding T_OutgoingInterval will be less than the desired interval T_TargetInterval if this request is acted on immediately upon receipt; thus, the corresponding outgoing request 304 c is delayed so that the interval between request 304 b and 304 c (i.e., T_OutgoingInterval) is T_TargetInterval. The fourth incoming request 302 d has an actual T_OutgoingInterval that is at least, and even more than, the desired interval T_TargetInterval if this request is acted on immediately up receipt; thus, the corresponding outgoing request 304 d is completed essentially immediately with no delay. The fifth incoming request 302 e occurs at an actual T_IncomingInterval after the fourth request 302 d where the corresponding T_OutgoingInterval will be less than the desired interval T_TargetInterval if this request is acted on immediately upon receipt; thus, the corresponding outgoing request 304 d is delayed so that the interval between the request 304 c and 304 d (i.e., T_OutgoingInterval) is T_TargetInterval. The sixth incoming request 302 f occurs at an actual T_IncomingInterval after the fifth incoming request 302 e that is approximately the same as the desired interval T_TargetInterval; however, because of the delay in acting on the fifth request (i.e., the outgoing request 304 e), the corresponding outgoing request 304 f is also delayed so that the interval between the outgoing request 304 e and the outgoing request 304 f is T_TargetInterval.

The particular T_TargetInterval depends on the throttle queue depth and dynamically adjusts with the queue depth. For example, as the throttle queue depth becomes higher than the target value, the T_TargetInterval decreases, in order to process the requests more quickly and shorten the queue. The value for T_TargetInterval may be between, e.g., 1 microsecond and 100 microseconds.

Summarized, the interval between outgoing requests 304 (T_OutgoingInterval) is no less than T_TargetInterval, or, the interval between outgoing requests 304 (T_OutgoingInterval) is T_TargetInterval or greater, with the T_TargetInterval based on the throttle queue depth.

An overall example methodology of the delay unit (e.g., the delay unit 162) to throttle the requests is shown in FIG. 4 as method 400. In a first step 402, the queue is evaluated, or polled. If the queue is evaluated as empty, in step 404, then the method repeats thus far, returning to the first step 402. If the queue is not empty, the delay unit accepts one request (either a read or write request) from the queue in step 406. The timing of receipt of the request is compared to the time of the previous request in step 408. If the actual interval between the requests (T_OutgoingInterval) is greater than or equal to the target interval (T_TargetInterval), then the request is sent for completion in step 410. If the T_OutgoingInterval is less than the T_TargetInterval, then there is a delay, in step 412, for a duration equal to T_TargetInterval less T_OutgoingInterval. Once the T_TargetInterval time has elapsed (step 408), the request is sent for completion in step 410. In such a manner, the throttling module delays acting on the request, if needed, to obtain at least a minimum time interval between requests of T_TargetInterval.

The T_TargetInterval is dynamically adjusted based on the throttle queue depth, e.g., the average throttle queue depth. An average throttle queue depth may be calculated over a predetermined period of time, which also may be dynamically adjusted.

An overall example methodology for adjusting the T_TargetInterval based on an average throttle queue depth is shown in FIG. 5 as method 500. It is noted that this is merely one suitable method for adjusting the T_TargetInterval based on request queue depth.

In a first step 502, the average throttle queue depth (QD) is obtained. This may be any type of average, e.g., an arithmetic mean, moving average, exponential moving average, harmonic mean, quadratic mean, geometric mean, weighted mean, or trimmed or truncated mean. In one example, the average QD is 32. The average QD is calculated for a predetermined period of time, e.g., 1 second, 10 seconds; the predetermined period of time may also be adjusted. The average QD can be updated after a predetermined number of requests or calculations. In some implementations, the average QD may be further adjusted based on, e.g., temperature of the SSD, or power usage of the SSD.

After the average QD is obtained, a normalized difference of the QD is calculated in step 504, by dividing the target QD (TargetQD) less the average QD by a system QD. This system QD is the number of outstanding requests within the SSD, whether or not in the throttle queue. The TargetQD may be a fixed or dynamically adjusted value; in one example, the TargetQD is 8. The system QD may be an actual real time number or may be an averaged value. Either or both the TargetQD and the system QD may be further adjusted based on, e.g., temperature of the SSD, or power usage of the SSD.

With this normalized difference of the QD from step 504, the change for the T_TargetInterval is calculated in step 506, as the normalized difference of the QD multiplied by the current T_TargetInterval, multiplied by a coefficient α. The coefficient α defines the range of change for the T_TargetInterval per adjustment, and may be, e.g., a percentage. For example, when α is 5%, the change in T_TargetInterval is within 5% of the previous T_TargetInterval. Another example is when α is 10%. Although a can be any value, it is not desired to move the T_TargetInterval drastically, as drastic changes can provide less precise queue depth throttling. Thus, in some implementations, a is no greater than 25%, no greater than 15%, no greater than 10%, or no greater than 5%.

With the change in T_TargetInterval from step 506, the new T_TargetInterval is calculated in step 508. This new T_TargetInterval is transmitted to the delay unit of the throttling module (e.g., delay unit 162 of module 106 in FIG. 1) and used to delay, as necessary, the outgoing requests. After the new T_TargetInterval is transmitted, the process waits a time period (T_update) in step 512 before returning to step 502 and calculating a new average QD and eventual new T_TargetInterval. This T_update period can be based on a fixed time, an adjustable time, or other. An example T_update period is 500 microseconds. In an alternate implementation, an update cycle is based on the number of requests or the number of update cycles. For example, an update cycle may occur after 1000 requests.

The throttling modules described herein may be implemented as and/or processed as software or other machine-readable instructions. When implemented as processes in software, the modules may be provided as executable code which, when run on a device having a processor and computer capability, implement a process or method as described. The modules or code may be stored on a computer device or may be stored on a memory and may be connected to or downloaded to a computer device. In alternate implementations, the throttling modules may be implemented in hardware.

In summary, described herein are methodologies for improving the performance of an SSD by throttling the incoming requests by having a minimum time interval between actions, the minimum time interval based on the queue depth of the requests. The throttling is accomplished by a throttling queue module stored in memory of an SSD and implemented by a processor. The throttling module can be configured to throttle read requests, write requests, or both read and write requests.

The above specification and examples provide a complete description of the structure and use of exemplary implementations of the invention. The above description provides specific implementations. It is to be understood that other implementations are contemplated and may be made without departing from the scope or spirit of the present disclosure. The above detailed description, therefore, is not to be taken in a limiting sense. While the present disclosure is not so limited, an appreciation of various aspects of the disclosure will be gained through a discussion of the examples provided.

Unless otherwise indicated, all numbers expressing feature sizes, amounts, and physical properties are to be understood as being modified by the term “about,” whether or not the term “about” is immediately present. Accordingly, unless indicated to the contrary, the numerical parameters set forth are approximations that can vary depending upon the desired properties sought to be obtained by those skilled in the art utilizing the teachings disclosed herein.

As used herein, the singular forms “a”, “an”, and “the” encompass implementations having plural referents, unless the content clearly dictates otherwise. As used in this specification and the appended claims, the term “or” is generally employed in its sense including “and/or” unless the content clearly dictates otherwise.

Spatially related terms, including but not limited to, “bottom,” “lower”, “top”, “upper”, “beneath”, “below”, “above”, “on top”, “on,” etc., if used herein, are utilized for ease of description to describe spatial relationships of an element(s) to another. Such spatially related terms encompass different orientations of the device in addition to the particular orientations depicted in the figures and described herein. For example, if a structure depicted in the figures is turned over or flipped over, portions previously described as below or beneath other elements would then be above or over those other elements.

Since many implementations of the invention can be made without departing from the spirit and scope of the invention, the invention resides in the claims hereinafter appended. Furthermore, structural features of the different implementations may be combined in yet another implementation without departing from the disclosure or the recited claims. 

What is claimed is:
 1. A method comprising: monitoring a request queue in a solid state device (an SSD), the request queue comprising a first request and a second request having an actual time interval therebetween; determining a queue depth for the request queue; determining a target interval based on the queue depth and a target queue depth; and responsive to the actual time interval being less than the target interval, delaying acting on the second request until after the target interval.
 2. The method of claim 1, wherein: determining the queue depth for the request queue comprises determining an average queue depth for the request queue; and determining the target interval based on the queue depth and the target queue depth comprises determining the target interval based on the average queue depth and the target queue depth.
 3. The method of claim 2, wherein the average queue depth is an arithmetic mean, moving average, or exponential moving average based on the queue depth.
 4. The method of claim 1 further comprising modifying the target interval based on a modified queue depth to a modified target interval.
 5. The method of claim 1, wherein the target interval is adaptive based on an adaptive queue depth.
 6. The method of claim 1, wherein queue depth is an adaptive average queue depth and the target interval is adaptive based on the adaptive average queue depth.
 7. The method of claim 1, wherein determining a target interval comprises calculating a normalized difference in queue depth based on the target queue depth and the queue depth; and the method further comprises: modifying the target interval based on the normalized difference in queue depth to a modified target interval.
 8. The method of claim 7, wherein modifying the target interval includes modifying the target interval based on the normalized difference in queue depth and a coefficient.
 9. The method of claim 1, wherein determining a target interval comprises calculating a normalized difference in queue depth based on the target queue depth and the queue depth; and the method further comprises: modifying the target interval based on the difference in queue depth to a modified target interval.
 10. The method of claim 9, wherein modifying the target interval includes modifying the target interval based on the difference in queue depth and a coefficient.
 11. A method comprising: monitoring a request queue to a semiconductor storage device (an SSD), the request queue having a depth and comprising at least a first request, a second request, and an outgoing interval between the requests; and responsive to the outgoing interval being less than a target interval based on a target queue depth and the queue depth, setting an actual outgoing interval to be no less than the target interval and acting on the second request after expiration of the target interval.
 12. The method of claim 11, wherein the target interval is based on the target queue depth and an average queue depth over time.
 13. The method of claim 12, wherein the average queue depth is an arithmetic mean, moving average, or exponential moving average based on the queue depth.
 14. The method of claim 11, wherein the queue depth is an adaptive average queue depth and the target interval is adaptive based on the adaptive average queue depth.
 15. The method of claim 11, wherein the target interval is based on a normalized difference in queue depth based on the target queue depth and the queue depth; and the method further comprises: modifying the target interval based on the difference in queue depth to a modified target interval.
 16. A system comprising: a solid state device (SSD) and a host; and an interval throttling module stored in memory and implemented by a processor, the interval throttling module located in a data request completion path of the system and comprising a queue memory unit, a delay unit configured to delay acting on a second request if an outgoing interval between a first request and the second request is less than a target interval, and a calculator unit configured to dynamically adjust the target interval based on a throttle queue depth.
 17. The system of claim 16, wherein the interval throttling module is located in the SSD.
 18. The system of claim 17, wherein the interval throttling module is located between a back-end controller and a front-end controller.
 19. The system of claim 17, wherein the interval throttling module is located between a back-end controller and Flash memory.
 20. The system of claim 16, wherein the interval throttling module is located between the SSD and the host. 